Page({
    data: {
        isBlueTooth: false, //蓝牙搜索滑动开关状态
        devices: [], // 存储搜索到的蓝牙设备
        isSearching: false, // 标记是否正在搜索
        connectedDeviceId: '', // 当前已连接的设备ID
        isConnecting: false // 新增：标记是否正在连接中
    },
    
    // 处理蓝牙开关的切换事件
    buletoothChange(e) {
        const isChecked = e.detail.value;
        this.setData({ isBlueTooth: isChecked });
        if (isChecked) {
            console.log("蓝牙已开启，开始初始化蓝牙...");
            // 先关闭可能存在的蓝牙连接，确保重新初始化
            wx.closeBluetoothAdapter({
                complete: () => {
                    // 无论关闭成功与否，都重新初始化
                    this.initBluetooth();
                }
            });
        } else {
            console.log("蓝牙已关闭，停止搜索设备");
            this.stopBluetoothDiscovery(); // 停止搜索
            this.setData({ devices: [], connectedDeviceId: '' }); // 清空设备列表和连接状态
        }
    },
    
    // 初始化蓝牙模块
    initBluetooth() {
        wx.openBluetoothAdapter({
            success: () => {
                console.log("蓝牙模块初始化成功");
                // 延迟一点时间再开始搜索，确保蓝牙模块完全就绪
                setTimeout(() => {
                    this.startBluetoothDiscovery();
                }, 500);
            },
            fail: (err) => {
                console.error("蓝牙初始化失败", err);
                wx.showToast({
                    title: '请开启手机蓝牙',
                    icon: 'none',
                    duration: 2000
                });
                // 失败时关闭开关
                this.setData({ isBlueTooth: false });
            }
        });
    },
    
    // 开始搜索蓝牙设备
    startBluetoothDiscovery() {
        // 先清空之前的设备列表
        this.setData({ devices: [], isSearching: true });
        
        // 移除可能存在的旧监听
        wx.offBluetoothDeviceFound();
        
        // 监听新设备出现事件
        wx.onBluetoothDeviceFound((res) => {
            res.devices.forEach(device => {
                // 过滤掉重复设备和名称为空的设备
                if (!device.name && !device.localName) return;
                // 检查是否已经连接
                const isConnected = this.data.connectedDeviceId === device.deviceId;

                const existingDevices = this.data.devices;
                const isDuplicate = existingDevices.some(d => d.deviceId === device.deviceId);
                
                if (!isDuplicate) {
                    this.setData({
                        devices: [...existingDevices, {
                          ...device,  // 设备原有信息（deviceId、name、RSSI等）
                          connected: isConnected  // 动态添加的连接状态字段
                        }]
                      });
                }
            });
        });
        
        // 开始搜索
        wx.startBluetoothDevicesDiscovery({
            services: [], // 搜索所有服务的设备
            allowDuplicatesKey: false, // 不允许重复上报
            success: () => {
                console.log("开始搜索蓝牙设备...");
                // 延长搜索时间到5秒，提高设备发现率
                setTimeout(() => {
                    this.stopBluetoothDiscovery();
                }, 5000);
            },
            fail: (err) => {
                console.error("搜索设备失败", err);
                this.setData({ isSearching: false });
            }
        });
    },
    
    // 停止搜索蓝牙设备
    stopBluetoothDiscovery() {
        if (!this.data.isSearching) return;
        
        wx.stopBluetoothDevicesDiscovery({
            success: () => {
                console.log("已停止搜索蓝牙设备");
                this.setData({ isSearching: false });
            }
        });
        
        // 移除设备发现监听
        wx.offBluetoothDeviceFound();
    },

    // 连接蓝牙设备
    connectDevice(e) {
        const deviceId = e.currentTarget.dataset.deviceid;
        // 如果正在连接中，不重复处理
        if (this.data.isConnecting) {
            return;
        }
        // 判断当前点击的设备是否已经连接
        if (this.data.connectedDeviceId === deviceId) {
            // 已连接，执行断开操作
            this.disconnectDevice(deviceId);
            return;
        }

        // 显示加载提示
        this.setData({ isConnecting: true });
        wx.showLoading({
            title: '连接中...',
            mask: true // 显示透明蒙层，防止用户重复点击
        });

        // 先断开可能存在的连接
        if (this.data.connectedDeviceId) {
            wx.closeBLEConnection({
                deviceId: this.data.connectedDeviceId,
                complete: () => {
                    // 无论是否成功关闭，都继续新的连接
                    this.doConnect(deviceId);
                }
            });
        }else {
            // 没有已连接设备，直接连接新设备
            this.doConnect(deviceId);
        }
    },

    // 断开蓝牙设备连接
    disconnectDevice(deviceId) {
        // 显示加载提示
        this.setData({ isConnecting: true });
        // 执行断开操作
        wx.closeBLEConnection({
            deviceId: deviceId,
            success: (res) => {
                console.log("断开成功", res);
                // 更新之前连接设备的状态为未连接
                this.updateDeviceConnectionStatus(this.data.connectedDeviceId, false);
                // 更新连接状态
                this.updateDeviceConnectionStatus(deviceId, false);
                wx.showToast({
                    title: '断开成功',
                    mask: true,
                    duration:2000 //设置2000毫秒(2秒)
                });
            },
            fail: (err) => {
                console.error("断开失败", err);
                // 更新之前连接设备的状态为未连接
                this.updateDeviceConnectionStatus(this.data.connectedDeviceId, false);
            },
            complete: () => {
                // 无论成功失败，都关闭加载提示
                this.setData({ isConnecting: false });
            }
        });
    },


    // 实际执行连接的方法
    doConnect(deviceId) {
        // 开始连接
        wx.createBLEConnection({
            deviceId: deviceId,
            success: (res) => {
                console.log("连接成功", res);
                // 连接成功后，开始获取服务和特征值
                this.getBLEServices(deviceId);
                // 更新之前连接设备的状态为未连接
                this.updateDeviceConnectionStatus(this.data.connectedDeviceId, false);
                
                // 更新连接状态
                this.updateDeviceConnectionStatus(deviceId, true);
            },
            fail: (err) => {
                console.error("连接失败", err);
                // 更新之前连接设备的状态为未连接
                this.updateDeviceConnectionStatus(this.data.connectedDeviceId, false);
                setTimeout(()=>{
                    wx.showToast({
                        title: '连接失败',
                        icon: 'error',
                        duration:2000 //设置2000毫秒(2秒)
                    });
                },300); //延迟300毫秒,确保加载提示已经关闭
            },
            complete: () => {
                // 无论成功失败，都关闭加载提示
                this.setData({ isConnecting: false });
                wx.hideLoading();
            }
        });
    },

    // 更新设备连接状态
    updateDeviceConnectionStatus(deviceId, isConnected) {
        const devices = this.data.devices.map(device => {
            if (device.deviceId === deviceId) {
                return { ...device, connected: isConnected };
            }
            return device;
        });
        this.setData({
            devices: devices,
            connectedDeviceId: isConnected ? deviceId : ''
        });
    },

    // 获取蓝牙设备服务
    getBLEServices(deviceId) {
        wx.getBLEDeviceServices({
            deviceId: deviceId,
            success: (res) => {
                console.log('设备服务列表:', res.services);
                
                // 遍历服务，寻找第一个可用的服务
                for (let i = 0; i < res.services.length; i++) {
                    const service = res.services[i];
                    // 获取该服务下的特征值
                    this.getBLECharacteristics(deviceId, service.uuid);
                }
            },
            fail: (err) => {
                console.error('获取服务失败:', err);
            }
        });
    },

    // 获取蓝牙设备特征值
    getBLECharacteristics(deviceId, serviceId) {
        wx.getBLEDeviceCharacteristics({
            deviceId: deviceId,
            serviceId: serviceId,
            success: (res) => {
                console.log(`服务 ${serviceId} 的特征值:`, res.characteristics);
                
                // 寻找可写的特征值
                for (let i = 0; i < res.characteristics.length; i++) {
                    const characteristic = res.characteristics[i];
                    // 找到支持写入操作的特征值
                    if (characteristic.properties.write) {
                        this.setData({
                            serviceId: serviceId,
                            characteristicId: characteristic.uuid
                        });
                        console.log(`已找到可写特征值: ${characteristic.uuid}`);
                        break;
                    }
                }
            },
            fail: (err) => {
                console.error('获取特征值失败:', err);
            }
        });
    },
    // 向蓝牙设备发送数据的通用方法
    sendDataToDevice(data) {
        // 检查是否已连接设备
        if (!this.data.connectedDeviceId) {
            wx.showToast({
                title: '请先连接设备',
                icon: 'none'
            });
            return;
        }

        // 检查是否获取到了服务和特征值
        if (!this.data.serviceId || !this.data.characteristicId) {
            wx.showToast({
                title: '未找到可写特征值',
                icon: 'none'
            });
            console.error('未找到可写的服务或特征值');
            return;
        }

        // 将字符串转换为ArrayBuffer
        let buffer;
        try {
            buffer = new TextEncoder().encode(data);
        } catch (e) {
            // 兼容旧版本浏览器/微信客户端
            buffer = this.stringToArrayBuffer(data);
        }

        // 发送数据
        wx.writeBLECharacteristicValue({
            deviceId: this.data.connectedDeviceId,
            serviceId: this.data.serviceId,
            characteristicId: this.data.characteristicId,
            value: buffer,
            success: () => {
                console.log(`数据发送成功: ${data}`);
                wx.showToast({
                    title: `发送成功: ${data}`,
                    icon: 'success',
                    duration: 1500
                });
            },
            fail: (err) => {
                console.error('数据发送失败:', err);
                wx.showToast({
                    title: '发送失败',
                    icon: 'none'
                });
            }
        });
    },

    // 字符串转ArrayBuffer的兼容方法
    stringToArrayBuffer(str) {
        const buffer = new ArrayBuffer(str.length);
        const dataView = new DataView(buffer);
        for (let i = 0; i < str.length; i++) {
            dataView.setUint8(i, str.charCodeAt(i));
        }
        return buffer;
    },

    // 页面卸载时关闭蓝牙
    onUnload() {
        wx.closeBluetoothAdapter();
    },

    // 在蓝牙初始化成功或发送方法定义后，注册到全局
    onLoad() {
        // 获取全局实例
        const app = getApp();
        // 将当前页面的 sendDataToDevice 方法挂载到全局
        app.globalData.bluetooth.sendDataToDevice = this.sendDataToDevice.bind(this);
    },
})